Bug

A generic match arm let s: Opt<T> (where T is the enclosing function's type var) lowered its runtime type-test to an exact reified type-arg comparison. When inference pins T to a supertype union of the scrutinee's actual type arg — which happens whenever a default: T argument subtypes, so T reifies to the un-subsumed join Shape | Sq while the value is a plain Opt<Shape> — the exact Shape | Sq == Shape check fails, the arm silently misses, and control falls through to the default.

Repro

interface Shape { function area(self) -> int }
class Sq { s: int, implements Shape { function area(self) -> int { self.s * self.s } } }
class Opt<T> { value: T }
class Non {}

function mk<T>(v: T) -> Opt<T> | Non { Opt<T> { value: v } }

function unwrap_or<T>(o: Opt<T> | Non, default: T) -> T {
  match (o) {
    let s: Opt<T> => s.value,
    _ => default,
  }
}

function bug() -> int {
  let o: Opt<Shape> | Non = mk<Shape>(Sq { s: 5 });
  unwrap_or(o, Sq { s: 0 }).area()   // T infers to `Shape | Sq`
}

bug() returned 0 (expected 25). Widening the default so T pins to Shape directly (let d: Shape = Sq{s:0}) already returned 25. Probing reflect.type_of<T>() inside unwrap_or prints "Shape | Sq", confirming the reified frame type-arg is the un-subsumed join, not Sq.

Root cause

crates/baml_compiler2_mir/src/lower.rs, lower_pattern_test: the typevar-carrying class-pattern branch built the IsType template via ty_to_template, whose TypeVar arm lowers a frame type var to TyTemplate::TypeArgRef(N) (exact). The VM's guard_template_matches (crates/bex_vm/src/vm.rs) checks TypeArgRef(n) with frame_type_args[n] == actual — structural equality. With frame_type_args[0] = Union([Shape, Sq]) and the scrutinee Opt<Shape>'s class_type_args[0] = Shape, Union([Shape, Sq]) == Shape is false, so the arm never matches.

The sibling TypeArgRefOrWildcard(n) arm instead does actual.is_subtype_of(expected) — the correct covariant "does this value belong to type Opt<T>" semantics — and this is exactly what interface class-dispatch guards already use (emit_interface_class_guard_branch, via tir2_to_dispatch_guard_template). Match arms were inconsistently on the exact path.

Fix (MIR layer)

Swap the single ty_to_template call at the typevar class-pattern arm for tir2_to_dispatch_guard_template, so Opt<T> lowers to Class("Opt", [TypeArgRefOrWildcard(0)]). The VM then subtype-checks Shape <: (Shape | Sq) → matches → returns s.value → area() == 25.

This is preferred over broadening the VM's TypeArgRef comparison to is_subtype_of, because it keeps TypeArgRef's exact-materialization meaning intact and makes match/catch class-pattern arms consistent with the already-shipping interface-class-dispatch guard.

Directionality / soundness

The subtype check stays directional: a strictly wider runtime type-arg still fails to match a narrower pinned T ((Shape|Sq).is_subtype_of(Sq) is false). Static typing + covariance already guarantee a well-typed scrutinee's runtime arg is <: the frame T, so this cannot over-match well-typed programs. Concrete parametric arms (Foo<int> vs Foo<string>) carry no enclosing type var and take the untouched exact concrete path.

Tests

• bex_vm unit tests on guard_template_matches locking the directional subtype semantics: under-match fix (Shape matches a Shape|Sq frame T), exact TypeArgRef stays exact, a wider runtime arg does not over-match a narrower T, an unknown frame slot is a wildcard, and concrete Foo<int> vs Foo<string> still discriminate.
• ns_generic_match_subtype e2e (real VM): narrow-default → 25, widened-default → 25 (control), non-Opt scrutinee falls through to the default, and concrete Foo<int>/Foo<string> still discriminate.
• projects/compiles/generic_match_typevar_arm snapshot project locks the emitted template as TypeArgRefOrWildcard (Opt<#0?>, was Opt<#0>) in the MIR/codegen snapshots.

Before / after

Snapshots

No existing e2e/compiled snapshot shifted (verified across the whole baml_src bytecode snapshot: only the new namespace snapshot and the global $init_test registrations appear). New snapshots: the generic_match_typevar_arm compiles project and the generic_match_subtype namespace. The _root.snap change is just the added test registrations.

Local runs green: cargo nextest run -p bex_vm -p baml_compiler2_mir (68 passed) and cargo test -p baml_tests -- --skip parser_stress (2758 passed, 0 failed).

https://linear.app/boundaryml2/issue/B-634

Summary by CodeRabbit

• Bug Fixes

  • Improved generic match pattern runtime type checks so subtype-based arms continue to match correctly when type inference widens generic arguments.

• Tests

  • Added end-to-end scenarios for widened generic types, correct arm selection, non-matching fallthrough, and concrete generic discrimination.
  • Added unit tests to verify VM dispatch-guard behavior for subtype-or-wildcard vs exact type-template matching.